#pragma once
#include <iostream>
#include <string>
#include<jsoncpp/json/json.h>
#include<memory>
#include"Log.hpp"
//分隔符
const std::string seq = "\r\n";
// 必须保证每次接收到的是一个完整的报文（报头+有效载荷）
// 添加报头
std::string EnCode(std::string& out)
{
    //len+分隔符+有效载荷+分隔符
    int len = out.size();
    out = std::to_string(len) + seq + out + seq;
    return out;
}
// // 解析报文
std::string DeCode(std::string& in)
{  
    // 1. 检查输入是否为空
    if(in.empty()) {
       //LOG(ERROR, "输入字符串为空");
        return "";
    }
    
    // 2. 找分隔符
    auto pos = in.find(seq);
    if(pos == std::string::npos || pos == 0) {
        LOG(ERROR, "未找到分隔符或分隔符在起始位置");
        return "";
    }
    
    // 3. 提取长度部分
    std::string lenstr = in.substr(0, pos);
    if(lenstr.empty()) {
        LOG(ERROR, "长度字符串为空");
        return "";
    }
    
    // 4. 转换为整数
    int len = 0;
    try {
        len = std::stoi(lenstr);
    } catch(...) {
        LOG(ERROR, "长度转换失败");
        return "";
    }
    
    // 5. 检查报文完整性
    int total = lenstr.size() + len + 2 * seq.size();
    if(in.size() < total) {
        LOG(ERROR, "有效载荷长度不一致");
        return "";
    }
    
    // 提取完整报文
    std::string package = in.substr(pos + seq.size(), len);
    in.erase(0, total);
    return package;
}
// 请求和答复都需要序列化和反序列化

class Request
{
public:
    Request()
    {
    }
    Request(int x, int y, char oper)
        : _x(x),
          _y(y),
          _oper(oper)
    {
    }
    // 序列化
    bool Serialize(std::string* out)
    {
        //使用json库进行序列化
        //1.使用Value对象
        Json::Value root;
        root["x"] = _x;
        root["y"] = _y;
        root["oper"] = _oper;
        //2.使用FastWriter对象
        Json::FastWriter writer;
        //3.将Value对象转换为字符串
        *out = writer.write(root);
        return true;    
    }   
    //反序列化
    bool Deserialize(const std::string& in)
    {
        //1.使用Value对象
        Json::Value root;
        //2.使用Reader对象
        Json::Reader reader;
        //3.将字符串转换为Value对象
        if(!reader.parse(in,root))
        {
            return false;
        }
        //4.从Value对象中提取数据
        _x = root["x"].asInt();
        _y = root["y"].asInt();
        _oper = root["oper"].asInt();
        return true;
    }
    void SetValue(int x,int y,char oper)
    {
        _x = x;
        _y = y;
        _oper = oper;
    }   
    ~Request()
    {
    }

public:
    int _x;
    int _y;
    char _oper;
};
class Response
{
public:
    Response()
    {
    }
    Response(int code, int result)
        : _code(code),
          _result(result)
    {
    }
    // 序列化
    bool Serialize(std::string* out)
    {
        //使用json库进行序列化
        //1.使用Value对象
        Json::Value root;
        root["code"] = _code;
        root["result"] = _result;
        //2.使用FastWriter对象
        Json::FastWriter writer;
        //3.将Value对象转换为字符串
        *out = writer.write(root);
        return true;    
    }   
    //反序列化
    bool Deserialize(const std::string& in)
    {
        //1.使用Value对象
        Json::Value root;
        //2.使用Reader对象
        Json::Reader reader;
        //3.将字符串转换为Value对象
        if(!reader.parse(in,root))
        {
            return false;
        }
        //4.从Value对象中提取数据
        _code = root["code"].asInt();
        _result = root["result"].asInt();
        return true;
    }   
    
    ~Response()
    {
    }
public:
    int _code;//错误码，0正确，1表示除0
    int _result;
};
class Factory
{
public:
    static std::shared_ptr<Request> BuildRequest()
    {
        return std::make_shared<Request>();
    }
    static std::shared_ptr<Response> BuildResponse()
    {
        return std::make_shared<Response>();
    }
};